home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d13 / patch12.arc / POPEN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-02  |  10.3 KB  |  340 lines
  1. /* popen/pclose:
  2.  *
  3.  * simple MS-DOS piping scheme to imitate UNIX pipes
  4.  *
  5.  * $Log:    popen.c,v $
  6.  * Revision 1.0.1  90/07/15  14:05:00  aas
  7.  * fix assumption of trailing "/" in popen()
  8.  *
  9.  * Revision 1.0.0  88/08/03  20:08:00  ???
  10.  * original distribution: author unknown
  11.  * found on simtel20 as pd1:<msdos.turbo-c>popen.arc
  12.  *
  13.  */
  14.  
  15. #include <stdio.h>
  16. #include <ctype.h>
  17. #include <alloc.h>
  18. #include <string.h>
  19. #include <errno.h>
  20. #include <setjmp.h>
  21. #include <process.h>
  22.  
  23. #include "popen.h"
  24.  
  25. extern char *getenv( char * );
  26.  
  27. #ifndef    _NFILE
  28. # define    _NFILE    OPEN_MAX    /* Number of open files */
  29. #endif    _NFILE
  30.  
  31. #define READIT    1            /* Read pipe */
  32. #define WRITEIT    2            /* Write pipe */
  33.  
  34. static char *prgname[ _NFILE ];        /* program name if write pipe */
  35. static int pipetype[ _NFILE ];        /* 1=read 2=write */
  36. static char *pipename[ _NFILE ];    /* pipe file name */
  37.  
  38. /*
  39.  *------------------------------------------------------------------------
  40.  * stoupper: Convert string to uppercase (in place)
  41.  *------------------------------------------------------------------------
  42.  */
  43.  
  44. static void
  45. stoupper( s )
  46. char *s;
  47. {
  48.    int c;
  49.    for( ; (c = *s) != '\0'; ++s ) {
  50.       if( islower( c ) ) *s = _toupper( c );
  51.    }
  52. }
  53.  
  54. /*
  55.  *------------------------------------------------------------------------
  56.  * strsave: Copy string into malloc'ed memory and return address
  57.  *------------------------------------------------------------------------
  58.  */
  59.  
  60. static char *
  61. strsave( s )
  62. char *s;
  63. {
  64.    char *sp = malloc( strlen( s ) + 1 );
  65.    if( sp != (char *) NULL ) (void) strcpy( sp, s );
  66.    return( sp );
  67. }
  68.  
  69. /*
  70.  *------------------------------------------------------------------------
  71.  * strfree: Returm strsave'd string memory
  72.  *------------------------------------------------------------------------
  73.  */
  74.  
  75. static void
  76. strfree( s )
  77. char *s;
  78. {
  79.    if( s != (char *) NULL ) free( s );
  80. }
  81.  
  82. /*
  83.  *------------------------------------------------------------------------
  84.  * run: Execute command via SHELL or COMSPEC
  85.  *------------------------------------------------------------------------
  86.  */
  87.  
  88. static int
  89. run( command )
  90. char *command;
  91. {
  92.    jmp_buf panic;            /* How to recover from errors */
  93.    int lineno;                /* Line number where panic happened */
  94.    char *shell;                /* Command processor */
  95.    char *s = (char *) NULL;        /* Holds the command */
  96.    int s_is_malloced = 0;        /* True if need to free 's' */
  97.    static char *command_com = "COMMAND.COM";
  98.    int status;                /* Return codes */
  99.    char *shellpath;            /* Full command processor path */
  100.    char *bp;                /* Generic string pointer */
  101.    static char dash_c[ 3 ] = { '?', 'c', '\0' };
  102.    if( (lineno = setjmp( panic )) != 0 ) {
  103.       int E = errno;
  104. #ifdef    DEMO
  105.       fprintf( stderr, "RUN panic on line %d: %d\n", lineno, E );
  106. #endif    DEMO
  107.       if( s_is_malloced && (s != (char *) NULL) ) strfree( s );
  108.       errno = E;
  109.       return( -1 );
  110.    }
  111.    if( (s = strsave( command )) == (char *) NULL ) longjmp( panic, __LINE__ );
  112.    /* Determine the command processor */
  113.    if( ((shell = getenv( "SHELL" )) == (char *) NULL) &&
  114.        ((shell = getenv( "COMSPEC" )) == (char *) NULL) ) shell = command_com;
  115.    stoupper( shell );
  116.    shellpath = shell;
  117.    /* Strip off any leading backslash directories */
  118.    shell = strrchr( shellpath, '\\' );
  119.    if( shell != (char *) NULL ) ++shell;
  120.    else                         shell = shellpath;
  121.    /* Strip off any leading slash directories */
  122.    bp = strrchr( shell, '/'  );
  123.    if( bp != (char *) NULL ) shell = ++bp;
  124.    if( strcmp( shell, command_com ) != 0 ) {
  125.       /* MKS Shell needs quoted argument */
  126.       char *bp;
  127.       if( (bp = s = malloc( strlen( command ) + 3 )) == (char *) NULL ) 
  128.      longjmp( panic, __LINE__ );
  129.       *bp++ = '\'';
  130.       while( (*bp++ = *command++) != '\0' );
  131.       *(bp - 1) = '\'';
  132.       *bp = '\0';
  133.       s_is_malloced = 1;
  134.    } else s = command;
  135.    dash_c[ 0 ] = getswitch();
  136.    /* Run the program */
  137. #ifdef    DEMO
  138.    fprintf( stderr, "Running: (%s) %s %s %s\n", shellpath, shell, dash_c, s );
  139. #endif    DEMO
  140.    status = spawnl( P_WAIT, shellpath, shell, dash_c, s, (char *) NULL );
  141.    if( s_is_malloced ) free( s );
  142.    return( status );
  143. }
  144.  
  145. /* 
  146.  *------------------------------------------------------------------------
  147.  * uniquepipe: returns a unique file name 
  148.  *------------------------------------------------------------------------
  149.  */
  150.  
  151. static char *
  152. uniquepipe()
  153. { 
  154.    static char name[ 14 ];
  155.    static short int num = 0;
  156.    (void) sprintf( name, "pipe%04d.tmp", num++ );
  157.    return( name );
  158. }
  159.  
  160. /*
  161.  *------------------------------------------------------------------------
  162.  * resetpipe: Private routine to cancel a pipe
  163.  *------------------------------------------------------------------------
  164.  */
  165.  
  166. static void
  167. resetpipe( fd )
  168. int fd;
  169. {
  170.    char *bp;
  171.    if( (fd >= 0) && (fd < _NFILE) ) {
  172.       pipetype[ fd ] = 0;
  173.       if( (bp = pipename[ fd ]) != (char *) NULL ) {
  174.      (void) unlink( bp );
  175.      strfree( bp );
  176.      pipename[ fd ] = (char *) NULL;
  177.       }
  178.       if( (bp = prgname[ fd ]) != (char *) NULL ) {
  179.      strfree( bp );
  180.      prgname[ fd ] = (char *) NULL;
  181.       }
  182.    }
  183. }
  184.  
  185. /* 
  186.  *------------------------------------------------------------------------
  187.  * popen: open a pipe 
  188.  *------------------------------------------------------------------------
  189.  */
  190.  
  191. FILE *popen( prg, type )
  192. char *prg;            /* The command to be run */
  193. char *type;            /* "w" or "r" */
  194. { 
  195.    FILE *p = (FILE *) NULL;    /* Where we open the pipe */
  196.    int ostdin;            /* Where our stdin is now */
  197.    int pipefd = -1;        /* fileno( p ) -- for convenience */
  198.    char tmpfile[ BUFSIZ ];    /* Holds name of pipe file */
  199.    char *tmpdir;        /* Points to directory prefix of pipe */
  200.    jmp_buf panic;        /* Where to go if there's an error */
  201.    int lineno;            /* Line number where panic happened */
  202.    char c;                            /* aas */
  203.    /* Find out where we should put temporary files */
  204.    if( (tmpdir = getenv( "TMPDIR" )) == (char *) NULL ) 
  205.       tmpdir = getenv( "TMP" );
  206.    if( tmpdir != (char *) NULL ) {
  207.       /* Use temporary directory if available */
  208.       (void) strcpy( tmpfile, tmpdir );
  209.       if((c=tmpfile[strlen(tmpfile)-1])!='/' && c!='\\')    /* aas */
  210.      (void) strcat( tmpfile, "/" );
  211.    } else *tmpfile = '\0';
  212.    /* Get a unique pipe file name */
  213.    (void) strcat( tmpfile, uniquepipe() );
  214.    if( (lineno = setjmp( panic )) != 0 ) {
  215.       /* An error has occurred, so clean up */
  216.       int E = errno;
  217. #ifdef    DEMO
  218.       fprintf( stderr, "POPEN panic on line %d: %d\n", lineno, E );
  219. #endif    DEMO
  220.       if( p != (FILE *) NULL ) (void) fclose( p );
  221.       resetpipe( pipefd );
  222.       errno = E;
  223.       return( (FILE *) NULL );
  224.    }
  225.    if( strcmp( type, "w" ) == 0 ) {
  226.       /* for write style pipe, pclose handles program execution */
  227.       if( (p = fopen( tmpfile, "w" )) != (FILE *) NULL ) {
  228.      pipefd = fileno( p );
  229.      pipetype[ pipefd ] = WRITEIT;
  230.      pipename[ pipefd ] = strsave( tmpfile );
  231.      prgname[ pipefd ]  = strsave( prg );
  232.      if( !pipename[ pipefd ] || !prgname[ pipefd ] ) longjmp( panic, __LINE__ );
  233.       }
  234.    } else if( strcmp( type, "r" ) == 0 ) {
  235.       /* read pipe must create tmp file, set up stdout to point to the temp
  236.       * file, and run the program.  note that if the pipe file cannot be
  237.       * opened, it'll return a condition indicating pipe failure, which is
  238.       * fine.
  239.       */
  240.       if( (p = fopen( tmpfile, "w" )) != (FILE *) NULL ) {
  241.      int ostdout;
  242.      pipefd = fileno( p );
  243.      pipetype[ pipefd ]= READIT;
  244.      if( (pipename[ pipefd ] = strsave( tmpfile )) == (char *) NULL ) 
  245.         longjmp( panic, __LINE__ );
  246.      /* Redirect stdin for the new command */
  247.      ostdout = dup( fileno( stdout ) );
  248.      if( dup2( fileno( stdout ), pipefd ) < 0 ) {
  249.         int E = errno;
  250.         (void) dup2( fileno( stdout ), ostdout );
  251.         errno = E;
  252.         longjmp( panic, __LINE__ );
  253.      }
  254.      if( run( prg ) != 0 ) longjmp( panic, __LINE__ );
  255.      if( dup2( fileno( stdout ), ostdout ) < 0 ) longjmp( panic, __LINE__ );
  256.      if( fclose( p ) < 0 ) longjmp( panic, __LINE__ );
  257.      if( (p = fopen( tmpfile, "r" )) == (FILE *) NULL ) longjmp( panic, __LINE__ );
  258.       }
  259.    } else {
  260.       /* screwy call or unsupported type */
  261.       errno = EINVFNC;
  262.       longjmp( panic, __LINE__ );
  263.    }
  264.    return( p );
  265. }
  266.  
  267. /* close a pipe */
  268.  
  269. int
  270. pclose( p )
  271. FILE *p;
  272. {
  273.    int pipefd = -1;        /* Fildes where pipe is opened */
  274.    int ostdout;            /* Where our stdout points now */
  275.    int ostdin;            /* Where our stdin points now */
  276.    jmp_buf panic;        /* Context to return to if error */
  277.    int lineno;            /* Line number where panic happened */
  278.    if( (lineno = setjmp( panic )) != 0 ) {
  279.       /* An error has occurred, so clean up and return */
  280.       int E = errno;
  281. #ifdef    DEMO
  282.       fprintf( stderr, "POPEN panic on line %d: %d\n", lineno, E );
  283. #endif    DEMO
  284.       if( p != (FILE *) NULL ) (void) fclose( p );
  285.       resetpipe( pipefd );
  286.       errno = E;
  287.       return( -1 );
  288.    }
  289.    pipefd = fileno( p );
  290.    if( fclose( p ) < 0 ) longjmp( panic, __LINE__ );
  291.    switch( pipetype[ pipefd ] ) {
  292.       case WRITEIT:
  293.      /* open the temp file again as read, redirect stdin from that
  294.       * file, run the program, then clean up.
  295.       */
  296.       if( (p = fopen( pipename[ pipefd ],"r" )) == (FILE *) NULL ) 
  297.      longjmp( panic, __LINE__ );
  298.       ostdin = dup( fileno( stdin ));
  299.       if( dup2( fileno( stdin ), fileno( p ) ) < 0 ) longjmp( panic, __LINE__ );
  300.       if( run( prgname[ pipefd ] ) != 0 ) longjmp( panic, __LINE__ );
  301.       if( dup2( fileno( stdin ), ostdin ) < 0 ) longjmp( panic, __LINE__ );
  302.       if( fclose( p ) < 0 ) longjmp( panic, __LINE__ );
  303.       resetpipe( pipefd );
  304.       break;
  305.    case READIT:
  306.       /* close the temp file and remove it */
  307.       resetpipe( pipefd );
  308.       break;
  309.    default:
  310.       errno = EINVFNC;
  311.       longjmp( panic, __LINE__ );
  312.       /*NOTREACHED*/
  313.    }
  314.    return( 0 );
  315. }
  316.  
  317. #ifdef    DEMO
  318. int
  319. main( argc, argv )
  320. int argc;
  321. char **argv;
  322. {
  323.    FILE *pipe;
  324.    char buf[ BUFSIZ ];
  325.    int n;
  326.    *buf = '\0';
  327.    for( n = 1; n < argc; ++n ) {
  328.       (void) strcat( buf, argv[ n ] );
  329.       (void) strcat( buf, " " );
  330.    }
  331.    if( (pipe = popen( buf, "r" )) != (FILE *) NULL ) {
  332.       while( fgets( buf, sizeof( buf ), pipe ) != (char *) NULL ) 
  333.      (void) fputs( buf, stdout );
  334.       if( pclose( pipe ) != 0 ) fprintf( stderr, "error closing pipe!\n" );
  335.    } else fprintf( stderr, "it didn't work!\n" );
  336.    exit( 0 );
  337.    /*NOTREACHED*/
  338. }
  339. #endif    DEMO
  340.